/*
 * dbUtil.js v0.0.1
 * (c) 2018 wangjunxiao
 * Released under the MIT License.
 * 
 * 优先使用同步方法，个别情况可以使用异步方法
 *  
 * 异步方法都没有测试
 * 
 */

(function (window) {
    var s = {};

    var _db = null;
    var _dbName = null;

    // s.init = function() {
    //     _db = api.require("db");
    // }

    /**
     * 打开数据库
     * @param {string} dbName  数据库名字
     * @param {string} dbPath  sqlite数据库文件名，带路径。数据库所在路径，不传时使用默认创建的路径。支持 fs://、widget://等协议（如fs://user.db）
     * @return {boolean} true 表示打开数据库成功， false表示打开数据库失败
     */
    s.open = function (dbName, dbPath) {
        _db = api.require('db');
        _dbName = dbName;

        var ret = _db.openDatabaseSync({
            name: dbName,
            path: dbPath,
        });

        if (ret.status) {
            db.log("成功打开本地数据库");
            // 兼容老的代码
            $C.db = _db;
            return true;
        } else {
            db.err("打开数据库失败", ret);
            return false;
        }
    }

    /**
     * 关闭数据库
     * @return {boolean} true 表示关闭数据库成功， false表示关闭数据库失败
     */
    s.close = function () {
        if (_dbName) {
            var ret = db.closeDatabaseSync({
                name: _dbName 
            })

            if(ret.status) {
                db.log("成功关闭数据库");
                return true;
            } else {
                db.err("关闭数据库失败", ret);
                return false;
            }
        } else {
            db.log("没有打开数据库");
            return true;
        }

    }

    /**
     * 查询一个对象, 异步方法
     * @param {*} sql
     * @param {function} callback 接受的参数是一个对象,或者null
     */
    s.selectOneAsync = function (sql, callback) {
        db.selectSql({
            name: _dbName,
            sql: sql
        }, function (ret, err) {
            db.log("selectOne: " + sql);

            if (ret.status) {
                if (ret.data.length > 0) callback(ret.data[0]);
                else callback(null);
            } else {
                db.log("selectOneAsync:执行错误." + JSON.stringify(err))

                callback(null);
            }
        });
    }

    /**
     * 查询一个对象, 同步方法
     * @param {*} sql
     * @return {object} 返回查询到的对象，或者null. 如果查询得到多个对象，返回第一个
     */
    s.selectOne = function (sql) {
        var ret = _db.selectSqlSync({
            name: _dbName,
            sql: sql
        })
        db.log("selectOneSync:" + sql);
        if (ret.status === true && ret.data.length > 0) {
            return ret.data[0];
        }

        if(ret.status === false) {
            db.log("selectOne:执行错误。" + JSON.stringify(ret));
        } else {
            db.log("selectOne: 没有查询到数据");
        }

        return null;
    }

    /**
     * 查询多个对象, 异步方法 
     * @param {string} sql
     * @param {function} callback 接受的对象数组, 失败返回null
     */
    s.selectAsync = function (sql, callback) {
        db.selectSql({
            name: _dbName,
            sql: sql
        }, function (ret, err) {
            db.log("selectAsync: " + sql);
            if (ret.status) {
                callback(ret.data);
            } else {
                db.log("selectAsync:执行错误." + JSON.stringify(err))
                callback(null);
            }
        })
    }

    /**
     * 查询多个对象 , 同步方法
     * @param {*} sql
     * @param {*} callback 接受的对象数组
     */
    s.select = function (sql) {
        var ret = _db.selectSqlSync({
            name: _dbName,
            sql: sql
        })
        
        db.log("select:" + sql);
        if (ret.status) {
            return ret.data;
        }

        db.log("select:执行错误." + JSON.stringify(ret))
        return null;
    }

    /**
     * 运行增，删，改的sql语句
     * @param {*} sql 要执行的insert sql语句
     * @param {*} callback callback(status), status表示sql语句是否执行成功
     */
    s.execSqlAsync = function (sql, callback) {
        //运行sql语句
        _db.executeSql({
            name: _dbName,
            sql: sql
        }, function (ret, err) {
            db.log("执行sql:" + sql);
           
            if (!ret.status) {
                db.log("执行sql失败:" + JSON.stringify(err));
                callback(false);
            } 
            
            callback(true);
        });
    }

    /**
     * 运行增，删，改的sql语句, 同步方法
     * 执行成功返回true
     * 执行失败返回false
     * @param {*} sql 要执行的insert sql语句
     */
    s.execSql = function (sql) {
        //运行sql语句
        var ret = _db.executeSqlSync({
            name: _dbName,
            sql: sql
        })
        db.log("execSqlSync:" + sql);

        if(!ret.status) db.log("execSqlSync:执行失败" + JSON.stringify(ret))

        return ret.status;
    }

    s.log = function (msg) {
        console.log(msg);
    }

    s.err = function (msg, json) {
        msg = msg ? msg : "发生错误";
        json = json ? json : {
            code: -1,
            msg: "未知错误。"
        };

        api.alert({
            title: '错误',
            msg: msg + ", code: " + json.code + ", 错误描述信息:" + json.msg
        });
    }

    window.db = s;
})(window)